{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.7.1 Perfectly Matched Layer (PML)\n",
    "====\n",
    "\n",
    "\n",
    "The use of (Perfectly Matched Layer) PML is a standard technique to numerically solve for outgoing waves in unbounded domains. Although scattering problems are posed in unbounded domains,  by bounding the scatterer and any inhomogeneities within a PML, one is able to truncate to a bounded computational domain. In this tutorial we see how to use PML for \n",
    "- source problems, and \n",
    "- eigenvalue problems (resonances)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ngsolve import *\n",
    "from ngsolve.webgui import Draw\n",
    "from netgen.geom2d import SplineGeometry\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Source problem\n",
    "\n",
    "Consider the problem of finding $u$ satisfying \n",
    "\n",
    "$$\n",
    "-\\Delta u - \\omega^2 u = f \\qquad \\text{ in } \\mathbb{R}^2\n",
    "$$\n",
    "\n",
    "together with the Sommerfeld (outgoing) radiation condition at infinity\n",
    "\n",
    "$$\n",
    "\\lim_{r \\to \\infty} r^{1/2}\n",
    "\\bigg( \n",
    "\\frac{\\partial u }{ \\partial r} - i \\omega u \n",
    "\\bigg) = 0\n",
    "$$\n",
    "\n",
    "where $r$ is the radial coordinate. \n",
    "\n",
    "\n",
    "We consider an example where $f$ represents a time-harmonic pulse that is  essentially zero except for a small region."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "geo = SplineGeometry()\n",
    "geo.AddCircle( (0,0), 1.4, leftdomain=2, bc=\"outerbnd\")\n",
    "geo.AddCircle( (0,0), 1, leftdomain=1, rightdomain=2, bc=\"innerbnd\")\n",
    "geo.SetMaterial(1, \"inner\")\n",
    "geo.SetMaterial(2, \"pmlregion\")\n",
    "mesh = Mesh(geo.GenerateMesh (maxh=0.1))\n",
    "mesh.Curve(3)\n",
    "\n",
    "f = exp(-20**2*((x-0.3)*(x-0.3)+y*y))\n",
    "Draw(f, mesh, 'f')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how geometry is divided into an `inner` disk and and an outer \n",
    "annulus called `pmlregion`.\n",
    "\n",
    "The PML facility in NGSolve implements a complex coordinate transformation on a given mesh region (which in  this example is  `pmlregion`). When this complex variable change is applied to the outgoing solution in the PML region,  it becomes a a function that decays exponentially as $r \\to \\infty$, allowing us to truncate the unbounded domain.\n",
    "\n",
    "With the following single line, we tell NGSolve to turn on this coordinate transformation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh.SetPML(pml.Radial(rad=1,alpha=1j,origin=(0,0)), \"pmlregion\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then a  radial PML is set in the exterior of a disk \n",
    "centered at `origin`  of radius `rad`. In addition to \n",
    "`origin` and `rad`, the keyword argument `alpha` may be used to set\n",
    "the PML strength, which determines the rate of increase in the imaginary\n",
    "part of the coordinate map as radius increases.\n",
    "\n",
    "Having set the PML, the rest of the code now  looks very much like that  in [1.7](../unit-1.7-helmholtz/helmholtz.ipynb):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fes = H1(mesh, order=4, complex=True)\n",
    "u = fes.TrialFunction()\n",
    "v = fes.TestFunction()\n",
    "\n",
    "omega = 10\n",
    "\n",
    "a = BilinearForm(fes)\n",
    "a += grad(u)*grad(v)*dx - omega**2*u*v*dx\n",
    "a += -1j*omega*u*v*ds(\"outerbnd\")\n",
    "\n",
    "b = LinearForm(fes)\n",
    "b += f * v * dx\n",
    "\n",
    "a.Assemble()\n",
    "b.Assemble()\n",
    "\n",
    "gfu = GridFunction(fes)\n",
    "gfu.vec.data = a.mat.Inverse() * b.vec\n",
    "Draw(gfu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that above we have kept the same Robin boundary conditions as in [1.7](../unit-1.7-helmholtz/helmholtz.ipynb).\n",
    "(Since the solution exponentially decays within PML, it is also common practice to put zero Dirichlet boundary conditions at the outer edge of the PML, an option that is also easily implementable in NGSolve using the `dirichlet` flag.)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eigenvalue problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PML can also be used to compute resonances on unbounded domains. Resonances of a scatterer $S$ are outgoing waves $u$ satisfying the homogeneous Helmholtz equation\n",
    "\n",
    "$$\n",
    "\\Delta u + \\omega^2 u = 0\n",
    " \\qquad \\text{ in } \\mathbb{R}^2 \\setminus S,\n",
    "$$\n",
    "\n",
    "i.e., $u$ is an eigenfunction of $-\\Delta$ associated to eigenvalue $\\lambda :=\\omega^2.$\n",
    "\n",
    "We truncate this unbounded-domain eigenproblem to a bounded-domain eigenproblem using PML. The following example computes the resonances of a cavity opening on one side into free space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "geo   = SplineGeometry()\n",
    "pnums = [geo.AddPoint(x, y, maxh=maxh) \n",
    "         for x,y,maxh in\n",
    "         [(-2, 0, 1), (-1, 0, 1), (-0.2, 0, 0.01), (-0.2, -0.8, 1), (0.2, -0.8, 1), (0.2, 0, 0.01), (1,0,1), (2,0,1), (2,2,1), (0,2,1), (-2,2,1), (1,1,1), (0,1,1), (-1,1,1) ]\n",
    "        ]\n",
    "lines = [(0,1,\"dir\",2,0), (1,2,\"dir\", 1,0), (2,3,\"dir\",1,0), (3,4,\"dir\",1,0), (4,5,\"dir\",1,0), (5,6,\"dir\",1,0), (6,7,\"dir\",2,0)]\n",
    "curves= [(7,8,9,\"outer\",2,0), (9,10,0,\"outer\",2,0), (6,11,12,\"inner\",1,2), (12,13,1,\"inner\",1,2) ]\n",
    "    \n",
    "for p1,p2,bc,left,right in lines:\n",
    "    geo.Append([\"line\", pnums[p1], pnums[p2]], bc=bc, leftdomain=left, rightdomain=right)\n",
    "for p1,p2,p3,bc,left,right in curves:\n",
    "    geo.Append([\"spline3\", pnums[p1], pnums[p2], pnums[p3]], bc=bc, leftdomain=left, rightdomain=right)\n",
    "\n",
    "geo.SetMaterial(1, \"air\")\n",
    "geo.SetMaterial(2, \"pml\")\n",
    "    \n",
    "mesh = Mesh(geo.GenerateMesh(maxh=0.1))\n",
    "mesh.Curve(5)\n",
    "Draw(mesh)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The top edge of the rectangular cavity opens into air, which is included in the computational domain as a semicircular region (neglecting backward propagating waves), while the remaining edges of the cavity are isolated from rest of space by perfect reflecting boundary conditions.\n",
    "\n",
    "You can identify the PML region in the Netgen GUI by double clicking on the outer part of the air."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mesh.SetPML(pml.Radial(rad=1, alpha=1j, origin=(0,0)), \"pml\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now make the complex symmetric system with PML incorporated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fes = H1(mesh, order=4, complex=True, dirichlet=\"dir\")\n",
    "\n",
    "u = fes.TrialFunction()\n",
    "v = fes.TestFunction()\n",
    "\n",
    "a = BilinearForm (fes, symmetric=True)\n",
    "a += grad(u)*grad(v)*dx\n",
    "\n",
    "m = BilinearForm (fes, symmetric=True)\n",
    "m += u*v*dx\n",
    "\n",
    "a.Assemble()\n",
    "m.Assemble()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For solving the eigenproblem, we use an Arnoldi eigensolver, to which a `GridFunction` with many vectors (allocated via keyword argument `multidim`) is input, together with `a` and `b`. A `shift` argument to `ArnoldiSolver` indicates the approximate location of expected eigenvalues."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = GridFunction(fes, multidim=50, name='resonances')\n",
    "\n",
    "with TaskManager():\n",
    "    lam = ArnoldiSolver(a.mat, m.mat, fes.FreeDofs(), \n",
    "                        u.vecs, shift=400)\n",
    "Draw(u)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print (\"lam: \", lam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The more \"confined\" modes have resonance values $\\omega$ that are closer to the real axis. Here are the computed $\\omega$-values plotted in the complex plane."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lamr = [sqrt(l).real for l in lam]\n",
    "lami = [sqrt(l).imag for l in lam]\n",
    "plt.plot(lamr, lami, \".\")\n",
    "plt.grid(True)\n",
    "plt.title('Computed $\\omega$ values')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
